home *** CD-ROM | disk | FTP | other *** search
/ Atari Forever 4 / Atari Forever 4.zip / Atari Forever 4.iso / PD_THEMA / EDITOREN / 7UP_PD / WINDOWS3.C < prev    next >
C/C++ Source or Header  |  1998-03-14  |  56KB  |  2,277 lines
  1. /* Window Bibliothek */
  2. /*****************************************************************************
  3. *
  4. *                                              7UP
  5. *                                      Modul: WINDOWS.C
  6. *                                     (c) by TheoSoft '90
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <stdarg.h>
  13. #include <string.h>
  14. #if GEMDOS
  15. #include <tos.h>
  16. #else
  17. #include <alloc.h>
  18. #endif
  19. #include <aes.h>
  20. #include <vdi.h>
  21.  
  22. #include "7up.h"
  23. #include "windows.h"
  24. #include "undo.h"
  25.  
  26. #define NOWINDOW     -1
  27. #define MIN_WIDTH  128
  28. #define MIN_HEIGHT 144
  29. #define VERTICAL    1
  30. #define HORIZONTAL 2
  31. #define TRUE     1
  32. #define FALSE    0
  33. #define notnull(a) ((a>0)?(a):(1))
  34. #define HORIZ_OFFSET 5
  35.  
  36. #define SCREEN            1
  37. #define PLOTTER         11
  38. #define PRINTER         21
  39. #define METAFILE        31
  40. #define CAMERA          41
  41. #define TABLET          51
  42.  
  43. extern int vdihandle,nodesktop,norm_point,toolbar_zeigen;
  44. extern int work_out[57];
  45. extern OBJECT *desktop, *winmenu;
  46. extern WINDOW *blkwp;
  47. extern LINESTRUCT *begcut,*endcut;
  48.  
  49. #define EXOB_TYPE(x) (x>>8)
  50.  
  51. int open_work(int device);
  52. void close_work(int handle, int device);
  53. WINDOW *Wfindblk(WINDOW *wp, WINDOW **blkwp, LINESTRUCT **beg, LINESTRUCT **end);
  54. long *get_cookie(long cookie);
  55. char *find_7upinf(char *path, char *ext, int mode);
  56.  
  57. static int x_desk,y_desk,w_desk,h_desk;
  58.  
  59. WINDOW _wind[MAXWINDOWS]=
  60. {
  61.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,0,0,0,0,0,0,0L,0L,0L,0L,8,16,0,0,0L,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  62.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  63.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  64.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  65.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  66.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  67.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L,
  68.     NOWINDOW,0,0,0,0,0,0,0,0,0L,0L,INSERT+INDENT,0,0,0,0,STRING_LENGTH,0L,0L,0L,0L,8,16,0,0,Wclear,0L,10,1,3,0L,0L,0L,0L,0L,0L
  69. };                      /* | | */
  70.  
  71. int align(register int x, register int n)      /* Umrechnung einer Koordinate auf die nächste  */
  72. {                                    /* durch n teilbare Stelle */
  73.     x += (n >> 2) - 1;        /* Runden und */
  74.     x = n * (x / n);            /* Rest entfernen */
  75.     return(x);
  76. }
  77.  
  78. int rc_intersect(register int p1[], register int p2[])
  79. {
  80.   register int tx = max(p1[0], p2[0]);
  81.   register int ty = max(p1[1], p2[1]);
  82.   register int tw = min(p1[0] + p1[2], p2[0] + p2[2]);
  83.   register int th = min(p1[1] + p1[3], p2[1] + p2[3]);
  84.  
  85.   p2[0] = tx;
  86.   p2[1] = ty;
  87.   p2[2] = tw - tx;
  88.   p2[3] = th - ty;
  89.  
  90.   return ((tw > tx) && (th > ty));
  91. }
  92.  
  93. WINDOW *Wcreate(int kind, int x, int y, int w, int h)
  94. {
  95.     register WINDOW *wp=(WINDOW *)0L;
  96.     register int i,handle;
  97.     int xw,yw,ww,hw,wh,ret;
  98.     char pathname[PATH_MAX];
  99.  
  100.     if(Wcount(CREATED)<(MAXWINDOWS-1))
  101.     {
  102.         _wind_get(0,WF_WORKXYWH,&x_desk,&y_desk,&w_desk,&h_desk);
  103.         wh=wind_create(kind,x,y,w,h);
  104.         if(wh>0 /* && wh<MAXWINDOWS */ )
  105.         {
  106.             handle=open_work(SCREEN);
  107. #if MSDOS
  108.             if(handle<3)
  109.             {
  110.                 wind_delete(wh);
  111.                 return(NULL);
  112.             }
  113. #endif
  114.             for(i=1; i<MAXWINDOWS; i++)
  115.                 if(!(_wind[i].w_state & CREATED)) /* jetzt: wh != arrayindex */
  116.                 {
  117.                     wp = &_wind[i];
  118.                     break;
  119.                 }
  120.             wp->wihandle = wh;
  121.             wp->vdihandle= handle;
  122.             for(i=DESKICN1; i<=DESKICN7; i++)
  123.                 if(desktop[i].ob_flags & HIDETREE) /* Icon suchen */
  124.                 {
  125.                     wp->icon=i;
  126.                     break;
  127.                 }
  128.             if(wp->fontid==1)
  129.             {
  130. #ifdef DEBUG
  131. printf("Set Window font: Id=%2d size=%2dpt\n", wp->fontid, wp->fontsize);
  132. #endif
  133.                 wp->fontsize = vst_point(wp->vdihandle,wp->fontsize,&ret,&ret,&wp->wscroll,&wp->hscroll);
  134.                 vqt_width(wp->vdihandle, 'W', &wp->wscroll, &ret, &ret);  /* Breite der Zeichen */
  135. #ifdef DEBUG
  136. printf("Got Window font: Id=%2d size=%2dpt\n", wp->fontid, wp->fontsize);
  137. #endif
  138.             }
  139.             wp->kind      = kind;
  140.             wp->w_state |= CREATED;
  141.             
  142.             if(toolbar_zeigen && rsrc_load(find_7upinf(pathname,"BAR",FALSE)))
  143.             {  /* Register für rsrc_free() sichern */
  144.                 wp->toolbaraddress=*(long *)&_GemParBlk.global[7];
  145. /*
  146.                 if(toolbar_senkrecht)
  147.                   rsrc_gaddr(R_TREE,1,&wp->toolbar);
  148.               else
  149. */
  150.                   rsrc_gaddr(R_TREE,0,&wp->toolbar);
  151.               toolbar_inst(winmenu, wp, wp->toolbar);
  152.             }
  153.             if( ! (wp->xwork && wp->ywork && wp->wwork, wp->hwork))
  154.             {/* Fensterarray wurde noch nicht benutzt, erstmalige Einstellung */
  155.                _wind_get(0,WF_TOP,&wh,&ret,&ret,&ret);
  156.                if(Wp(wh))
  157.                {
  158.                    _wind_get(wh,WF_WORKXYWH,&xw,&yw,&ww,&hw);
  159.                    x=xw;
  160.                    y=yw;
  161.                    w=ww;
  162.                    h=hw;
  163.                }
  164.                 _wind_calc(wh,WC_WORK,wp->kind,x,y,w,h,
  165.                     &wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  166.    
  167.                 wp->xwork=align(wp->xwork,wp->wscroll);
  168.                 wp->wwork=align(wp->wwork,wp->wscroll);
  169.                 wp->hwork=align(wp->hwork,wp->hscroll);
  170.                 wp->xwork+=wp->wscroll; /* Fenster nicht ganz groß, wg. Cursor */
  171.                 wp->wwork-=wp->wscroll;
  172.             }
  173.             else /* im Fensterarray stehen schon Werte drin */
  174.             {
  175.                 wp->xwork=align(wp->xwork,wp->wscroll);
  176.                 wp->wwork=align(wp->wwork,wp->wscroll);
  177.                 wp->hwork=align(wp->hwork,wp->hscroll);
  178.             }
  179.             if(wp->kind & VSLIDE)
  180.                 wind_set(wp->wihandle,WF_VSLSIZE,1000,0,0,0);
  181.             if(wp->kind & HSLIDE)
  182.                 wind_set(wp->wihandle,WF_HSLSIZE,1000,0,0,0);
  183.         }
  184.     }
  185.     return(wp);
  186. }
  187.  
  188. int Wopen(register WINDOW *wp)
  189. {
  190.     WINDOW *dummy;
  191.     int x,y,w,h,xi,yi,wi,hi;
  192.     register int i;
  193.     int ret;
  194. /*
  195.     int msgbuf[8];
  196. */
  197.     if(!wp)
  198.         return(FALSE);
  199.     if(!(wp->w_state & CREATED))
  200.         return(FALSE);
  201.     if(wp->w_state & OPENED)
  202.     {
  203.         Wtop(wp);
  204.         return(TRUE);
  205.     }
  206. /*
  207. /* Reaktion auf AC_CLOSE */
  208.    if(wp->wihandle == -2) /* Es kam ein AC_CLOSE, OPENED-Flag gelöscht */
  209.    {
  210.       wp->wihandle = wind_create(wp->kind,x_desk,y_desk,w_desk,h_desk);
  211.       if(wp->wihandle < 0)
  212.          return(FALSE);
  213.    }
  214. */
  215.     if((wp->kind & NAME) && wp->name)
  216.         wind_set(wp->wihandle,WF_NAME,wp->name,0,0,0);
  217.     if((wp->kind & INFO) && wp->info)
  218.         wind_set(wp->wihandle,WF_INFO,wp->info,0,0,0);
  219.     _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  220.         &x,&y,&w,&h);
  221.     if(y<y_desk) /* Korrektur, wenn jetzt mit Infozeile */
  222.     {
  223.         y=y_desk;
  224.         h-=y_desk;
  225.         _wind_calc(wp->wihandle,WC_WORK,wp->kind,x,y,w,h,
  226.             &wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  227.         wp->hwork=align(wp->hwork,wp->hscroll);
  228.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  229.             &x,&y,&w,&h);
  230.     }
  231.     iconposition(Wh(wp),&xi,&yi,&wi,&hi);
  232.     graf_growbox(xi,yi,wi,hi,x,y,w,h);
  233.     if(wind_open(wp->wihandle,x,y,w,h)>0)
  234.     {
  235.         for(i=1; i<MAXWINDOWS; i++)
  236.             _wind[i].w_state &= ~ONTOP; /* bit zurücksetzen */
  237.         wp->w_state |= OPENED;
  238.         wp->w_state |= ONTOP;
  239.         _wind_get(wp->wihandle,WF_WORKXYWH,&wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  240.         Wslupdate(wp,1+2+4+8);
  241.         
  242.         toolbar_adjust(wp);
  243.         
  244.         Wfindblk(wp,&blkwp,&begcut,&endcut);
  245. #if GEMDOS
  246.         AVAccOpenedWindow(wp->wihandle);
  247. #endif
  248.         return(TRUE);
  249.     }
  250.     return(FALSE);
  251. }
  252.  
  253. void Wattrchg(WINDOW *wp, int newkind)
  254. {
  255.     int xb,yb,wb,hb;
  256.     if(wp && newkind!=wp->kind)
  257.     {
  258.         graf_mouse(M_OFF,NULL);
  259.         Wcursor(wp);
  260.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,&xb,&yb,&wb,&hb);
  261.         if(wp->w_state & OPENED)
  262.             wind_close(wp->wihandle);
  263.         wind_delete(wp->wihandle);
  264.         wp->wihandle=wind_create(newkind,x_desk,y_desk,w_desk,h_desk);
  265.         wp->kind=newkind;
  266.         _wind_calc(wp->wihandle,WC_WORK,newkind,xb,yb,wb,hb,&wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  267.         wp->hwork=align(wp->hwork,wp->hscroll);
  268.         _wind_calc(wp->wihandle,WC_BORDER,newkind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,&xb,&yb,&wb,&hb);
  269. /* neu *********************************************************************/
  270.         if((wp->kind & NAME))
  271.         {
  272.             wind_set(wp->wihandle,WF_NAME,wp->name,0,0,0);
  273.         }
  274.         if((wp->kind & INFO))
  275.             Wnewinfo(wp,"");
  276.         adjust_best_position(wp);
  277.         if(wp->row > wp->hwork/wp->hscroll-1)/* Korrektur, wenn Cursor zu tief */
  278.         {
  279.             if(wp->cstr->prev)
  280.             {
  281.                 wp->cstr=wp->cstr->prev;
  282.                 wp->row--;
  283.             }
  284.         }
  285.         if(wp->w_state & OPENED)
  286.         {
  287.             wind_open(wp->wihandle,xb,yb,wb,hb);
  288.             _wind_get(wp->wihandle,WF_WORKXYWH,&wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  289.             Wsetrcinfo(wp);
  290.             wp->slhpos=wp->slwpos=0;
  291.             Wslupdate(wp,1+2+4+8);
  292.         }
  293.         Wcursor(wp);
  294.         graf_mouse(M_ON,NULL);
  295.     }
  296. }
  297.  
  298. char *Wname(WINDOW *wp)
  299. {
  300. #define APPNAMELEN 6 
  301.     char *cp;
  302.     if(wp && (wp->kind & NAME))
  303.     {
  304. #if GEMDOS
  305.         if(_GemParBlk.global[1] != 1)
  306.         {
  307.          return( wp->name[APPNAMELEN] == '*' ? &wp->name[APPNAMELEN+2] : &wp->name[APPNAMELEN]);
  308.         }
  309.         else
  310. #endif
  311.         {
  312.          return( *wp->name == '*' ? &wp->name[2] : wp->name);
  313.         }
  314.     }
  315.     return(NULL);
  316. }
  317.  
  318. void Wnewname(register WINDOW *wp, const char* name)
  319. {
  320.     char newname[PATH_MAX];
  321.  
  322.     if(wp && (wp->kind & NAME) && name)
  323.     {
  324. #if GEMDOS
  325.         if(_GemParBlk.global[1] != 1) /* mehr als eine Applikation gleichzeitig */
  326.             strcpy(newname,"[7UP] ");
  327.         else
  328. #endif
  329.             newname[0]=0;
  330.         if(wp->w_state & CHANGED)
  331.         {
  332.             strcat(strcat(newname,"* "),name);
  333.         }
  334.         else
  335.         {
  336.             strcat(newname,name);
  337.         }
  338.         if(strcmp(wp->name,newname))
  339.         {
  340.             wind_set(wp->wihandle,WF_NAME,strcpy(wp->name,newname),0,0,0);
  341.         }
  342.     }
  343. }
  344.  
  345. void Wnewinfo(register WINDOW *wp, const char* newinfo)
  346. {
  347.     if(wp && (wp->kind & INFO) && strcmp(wp->info,newinfo))
  348.         wind_set(wp->wihandle,WF_INFO,strcpy(wp->info,newinfo),0,0,0);
  349. }
  350.  
  351. int Wnewfont(WINDOW *wp, int fontid, int fontsize)
  352. {
  353.     if(wp)
  354.     {
  355.         wp->fontid=fontid;
  356.         vst_font(wp->vdihandle,fontid);
  357.         return(Wfontsize(wp,fontsize));
  358.     }
  359.     return(FALSE);
  360. }
  361.  
  362. int Wfontsize(register WINDOW *wp, int font)
  363. {
  364.     int array[4],oldw,oldh;
  365.     int ret;
  366.     long k;
  367.     if(wp)
  368.     {
  369.         k=wp->hsize/wp->hscroll;
  370.         oldh=wp->hscroll;
  371.         oldw=wp->wscroll;
  372.         wp->fontsize = vst_point(wp->vdihandle,font,&ret,&ret,&wp->wscroll,&wp->hscroll);
  373.         vqt_width(wp->vdihandle, 'W', &wp->wscroll, &ret, &ret);  /* Breite der Zeichen */
  374.  
  375.         wp->hsize =k*wp->hscroll;
  376.         wp->wsize=STRING_LENGTH*(long)wp->wscroll;
  377.         wp->hfirst=wp->hfirst*wp->hscroll/oldh; /* NICHT a*=x/y; !!! */
  378.         wp->wfirst=wp->wfirst*wp->wscroll/oldw;
  379.  
  380.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  381.             &array[0],&array[1],&array[2],&array[3]);
  382.         graf_mouse(M_OFF,0L);
  383.         Wcursor(wp);
  384.         Wmovesize(wp,array);
  385.         if(wp->w_state & OPENED)
  386.             Wredraw(wp,&wp->xwork); /* komplettes Redraw */
  387.         Wcursor(wp);
  388.         graf_mouse(M_ON,0L);
  389.         return(wp->fontsize);
  390.     }
  391.     return(FALSE);
  392. }
  393. /*
  394. static void _Wicndraw(const register WINDOW *wp, int dir, int clip[])
  395. {
  396.   MFDB     s, d;
  397.   BITBLK  *bitblk;
  398.   WORD     pxy [8];
  399.   WORD     index [2];
  400.   extern OBJECT *userimg;
  401.   
  402.     if(wp)
  403.     {
  404.         bitblk = userimg [WICON].ob_spec.bitblk;
  405.         
  406.         d.mp  = NULL; /* screen */
  407.         s.mp  = (VOID *)bitblk->bi_pdata;
  408.         s.fwp = bitblk->bi_wb << 3;
  409.         s.fh  = bitblk->bi_hl;
  410.         s.fww = s.fwp/16;
  411.         s.ff  = FALSE;
  412.         s.np  = 1;
  413.         
  414.         pxy [0] = 0;
  415.         pxy [1] = 0;
  416.         pxy [2] = s.fwp - 1;
  417.         pxy [3] = s.fh - 1;
  418.         pxy [4] = wp->xwork;
  419.         pxy [5] = wp->ywork;
  420.         pxy [6] = wp->xwork+wp->wwork-1;
  421.         pxy [7] = wp->ywork+wp->hwork-1;
  422.         
  423.         index [0] = BLACK;
  424.         index [1] = WHITE;
  425.         vr_recfl(wp->vdihandle,clip);                /* weißes rechteck in workspace */
  426.         vrt_cpyfm (wp->vdihandle, MD_REPLACE, pxy, &s, &d, index);     /* copy it */
  427.     }
  428. }
  429. */
  430. void Wredraw(register WINDOW *wp, int *rect)
  431. {
  432.   int area[4],clip[4];
  433.  
  434.   if(!wp)
  435.       return;
  436. #if MiNT
  437.     wind_update(BEG_UPDATE);
  438. #endif
  439.     _wind_get(wp->wihandle, WF_FIRSTXYWH, &area[0], &area[1], &area[2], &area[3]);
  440.     while( area[2] && area[3] )
  441.     {
  442.         if(rc_intersect(&x_desk,area))
  443.         {
  444.             if(rc_intersect(rect,area))
  445.             {
  446.                 clip[0]=area[0];
  447.                 clip[1]=area[1];
  448.                 clip[2]=area[0]+area[2]-1;
  449.                 clip[3]=area[1]+area[3]-1;
  450.                 vs_clip(wp->vdihandle,TRUE,clip);
  451. /*
  452.                if(wp->w_state & ICONIFIED)
  453.                    _Wicndraw(wp,VERTICAL+HORIZONTAL,clip);
  454.                else
  455. */
  456.                    wp->draw(wp,VERTICAL+HORIZONTAL,clip);
  457.             }
  458.         }
  459.         _wind_get(wp->wihandle, WF_NEXTXYWH, &area[0], &area[1], &area[2], &area[3]);
  460.     }
  461. #if MiNT
  462.     wind_update(END_UPDATE);
  463. #endif
  464. }
  465.  
  466. void Wtop(register WINDOW *wp)
  467. {
  468.     WINDOW *dummy;
  469.     register int i;
  470.  
  471.     for(i=1; i<MAXWINDOWS; i++)
  472.     {
  473.         _wind[i].w_state &= ~ONTOP; /* bit zurücksetzen */
  474.     }
  475.     if(wp)
  476.     {
  477.         wp->w_state |= ONTOP;
  478.         wp->cspos=wp->col; /* Cursormüll vermeiden */
  479.         wind_set(wp->wihandle,WF_TOP,0,0,0,0);
  480.         Wfindblk(wp,&blkwp,&begcut,&endcut);
  481.  
  482.         toolbar_adjust(wp);
  483.    }
  484. }
  485.  
  486. void Wbottom(register WINDOW *wp) /*14.4.94*/
  487. {
  488.     if(wp) /* WiNX */
  489.     {
  490.         wind_set(wp->wihandle,25/*WF_BOTTOM*/,0,0,0,0);
  491.    }
  492. }
  493.  
  494. void Wfull(register WINDOW *wp)
  495. {
  496.     int nx,ny,nw,nh,ox,oy,ow,oh;
  497.     register long i, oldrow;
  498.     long oldhfirst;
  499.  
  500.     if(wp)
  501.     {
  502.         _wind_get(wp->wihandle,WF_CURRXYWH,&ox,&oy,&ow,&oh);
  503.         if(wp->w_state & FULLED && wp->w_state & OPENED)
  504.         {
  505.             _wind_get(wp->wihandle,WF_PREVXYWH,&nx,&ny,&nw,&nh);
  506.             graf_shrinkbox(nx,ny,nw,nh,ox,oy,ow,oh);
  507.         }
  508.         else
  509.         {
  510.             _wind_get(0,WF_WORKXYWH,&nx,&ny,&nw,&nh);
  511.             graf_growbox(ox,oy,ow,oh,nx,ny,nw,nh);
  512.         }
  513.         _wind_calc(wp->wihandle,WC_WORK,wp->kind,nx,ny,nw,nh,&wp->xwork,&wp->ywork,
  514.             &wp->wwork,&wp->hwork);
  515.  
  516.         wp->xwork=align(wp->xwork,wp->wscroll);
  517.         wp->wwork=align(wp->wwork,wp->wscroll);
  518.         wp->hwork=align(wp->hwork,wp->hscroll);
  519.  
  520.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  521.             &nx,&ny,&nw,&nh);
  522.         wind_set(wp->wihandle,WF_CURRXYWH,nx,ny,nw,nh);
  523.         _wind_get(wp->wihandle,WF_WORKXYWH,&wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  524.         
  525.         toolbar_adjust(wp);
  526.         
  527.         if(wp->type)        /* windowtype == GRAPHIC ? */
  528.             wp->hfirst=0;
  529.         else
  530.         {
  531.             oldhfirst=wp->hfirst;
  532.             oldrow=wp->row;
  533.             if(wp->hsize < wp->hwork) /* wenn text < hwork */
  534.                 wp->hfirst=0;
  535.             if(wp->hfirst + wp->hwork > wp->hsize)
  536.                 wp->hfirst=wp->hsize - wp->hwork;
  537.             if(wp->hfirst < 0)
  538.                 wp->hfirst=0;
  539.             if(wp->col > wp->wwork/wp->wscroll-1)
  540.                 wp->col=wp->wwork/wp->wscroll-1;
  541.             if(wp->row > wp->hwork/wp->hscroll-1)
  542.                 wp->row=wp->hwork/wp->hscroll-1;
  543.             if(wp->row < oldrow)
  544.                 for(i=0; i<(oldrow-wp->row); i++)
  545.                 {
  546.                      wp->cstr=wp->cstr->prev;
  547.                 }
  548.             if(wp->hfirst<oldhfirst)
  549.             {
  550.                 for(i=0; i<(oldhfirst-wp->hfirst)/wp->hscroll; i++)
  551.                 {
  552.                      wp->wstr=wp->wstr->prev;
  553.                 }
  554.                 Wredraw(wp,&wp->xwork);
  555.             }
  556.         }
  557.         Wslupdate(wp,1+2+4+8);
  558.         wp->w_state ^= FULLED;
  559.     }
  560. }
  561.  
  562. void Wadjust(WINDOW *wp)
  563. {
  564.     GRECT grect;
  565.     int xdesk,ydesk,wdesk,hdesk;
  566.  
  567.     if(wp)
  568.     {
  569.         _wind_get(0,WF_WORKXYWH,&xdesk,&ydesk,&wdesk,&hdesk);
  570.         _wind_calc(wp->wihandle,WC_WORK,wp->kind,xdesk,ydesk,wdesk,hdesk,
  571.             &wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  572.                               /* anpassen an Umbruch */
  573.         wp->wwork=min(wp->umbruch*wp->wscroll,wp->wwork);
  574.         wp->xwork=align(wp->xwork,wp->wscroll);
  575.         wp->wwork=align(wp->wwork,wp->wscroll);
  576.         wp->hwork=align(wp->hwork,wp->hscroll);
  577.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  578.             &grect.g_x,&grect.g_y,&grect.g_w,&grect.g_h);
  579.         Wmovesize(wp,(int *)&grect);
  580.     }
  581. }
  582.  
  583. void Wmovesize(register WINDOW *wp, int nxywh[])
  584. {
  585.     int ox,oy,ow,oh;
  586.     register long i, oldrow, oldhfirst;
  587.  
  588.     if(wp /*&& wp->w_state & OPENED*/)
  589.     {
  590.         if(nxywh[2]<MIN_WIDTH)
  591.             nxywh[2]=MIN_WIDTH;
  592.         if(nxywh[3]<MIN_HEIGHT)
  593.             nxywh[3]=MIN_HEIGHT;
  594.         _wind_calc(wp->wihandle,WC_WORK,wp->kind,nxywh[0],nxywh[1],nxywh[2],nxywh[3],
  595.             &wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  596.  
  597.         wp->xwork=align(wp->xwork,wp->wscroll);
  598.         wp->wwork=align(wp->wwork,wp->wscroll);
  599.         wp->hwork=align(wp->hwork,wp->hscroll);
  600.  
  601.         toolbar_adjust(wp);
  602.  
  603.         if(!(wp->w_state & OPENED))
  604.             return;
  605.  
  606.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  607.             &nxywh[0],&nxywh[1],&nxywh[2],&nxywh[3]);
  608.  
  609.         wind_set(wp->wihandle,WF_CURRXYWH,nxywh[0],nxywh[1],nxywh[2],nxywh[3]);
  610.         _wind_get(wp->wihandle,WF_WORKXYWH,&wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  611.         
  612.         toolbar_adjust(wp);
  613.         
  614.         if(wp->type)        /* windowtype == GRAPHIC ? */
  615.             wp->hfirst=0;
  616.         else
  617.         {
  618.             oldhfirst=wp->hfirst;
  619.             oldrow=wp->row;
  620.             if(wp->hsize < wp->hwork) /* wenn text < hwork */
  621.                 wp->hfirst=0;
  622.             if(wp->hfirst + wp->hwork > wp->hsize)
  623.                 wp->hfirst=wp->hsize - wp->hwork;
  624.             if(wp->hfirst < 0)
  625.                 wp->hfirst=0;
  626.             if(wp->col > wp->wwork/wp->wscroll-1)
  627.                 wp->col=wp->wwork/wp->wscroll-1;
  628.             if(wp->row > wp->hwork/wp->hscroll-1)
  629.                 wp->row=wp->hwork/wp->hscroll-1;
  630.             if(wp->row < oldrow)                     /* kleiner */
  631.                 for(i=0; i<(oldrow-wp->row); i++)
  632.                 {
  633.                      wp->cstr=wp->cstr->prev;
  634.                 }
  635.             if(wp->hfirst<oldhfirst)
  636.             {
  637.                 for(i=0; i<(oldhfirst-wp->hfirst)/wp->hscroll; i++)
  638.                 {
  639.                      wp->wstr=wp->wstr->prev;
  640.                 }
  641.                 if(wp->w_state & OPENED)
  642.                     Wredraw(wp,&wp->xwork);
  643.             }
  644.             if(wp->row > oldrow)                     /* größer */
  645.                 for(i=0; i<-(oldrow-wp->row); i++)
  646.                 {
  647.                      wp->cstr=wp->cstr->next;
  648.                 }
  649.             if(wp->hfirst>oldhfirst)
  650.             {
  651.                 for(i=0; i<-(oldhfirst-wp->hfirst)/wp->hscroll; i++)
  652.                 {
  653.                      wp->wstr=wp->wstr->next;
  654.                 }
  655.                 if(wp->w_state & OPENED)
  656.                     Wredraw(wp,&wp->xwork);
  657.             }
  658.         }
  659.         Wslupdate(wp,1+2+4+8);
  660.         wp->w_state &= ~FULLED;
  661.     }
  662. }
  663.  
  664. static void _Wtile(void)
  665. {
  666.     extern WINDOW _wind[MAXWINDOWS];
  667.  
  668.    typedef struct
  669.    {
  670.       GRECT rect[MAXWINDOWS];
  671.    }TWindpos;
  672.  
  673.    TWindpos pos;
  674.    int i,k,xd,yd,wd,hd;
  675.  
  676.    wind_get(0,WF_WORKXYWH,&xd,&yd,&wd,&hd);
  677.  
  678.    switch(Wcount(OPENED))
  679.    {
  680.       case 1:
  681.          pos.rect[1].g_x = xd;
  682.          pos.rect[1].g_y = yd;
  683.          pos.rect[1].g_w = wd;
  684.          pos.rect[1].g_h = hd;
  685.  
  686.          break;
  687.       case 2:
  688.          pos.rect[1].g_x = xd;
  689.          pos.rect[1].g_y = yd;
  690.          pos.rect[1].g_w = wd;
  691.          pos.rect[1].g_h = hd/2;
  692.  
  693.          pos.rect[2].g_x = xd;
  694.          pos.rect[2].g_y = yd+hd/2;
  695.          pos.rect[2].g_w = wd;
  696.          pos.rect[2].g_h = hd/2;
  697.  
  698.          break;
  699.       case 3:
  700.          pos.rect[1].g_x = xd;
  701.          pos.rect[1].g_y = yd;
  702.          pos.rect[1].g_w = wd;
  703.          pos.rect[1].g_h = hd/3;
  704.  
  705.          pos.rect[2].g_x = xd;
  706.          pos.rect[2].g_y = yd+hd/3;
  707.          pos.rect[2].g_w = wd;
  708.          pos.rect[2].g_h = hd/3;
  709.  
  710.          pos.rect[3].g_x = xd;
  711.          pos.rect[3].g_y = yd+2*hd/3;
  712.          pos.rect[3].g_w = wd;
  713.          pos.rect[3].g_h = hd/3;
  714.  
  715.          break;
  716.       case 4:
  717.          pos.rect[1].g_x = xd;
  718.          pos.rect[1].g_y = yd;
  719.          pos.rect[1].g_w = wd/2;
  720.          pos.rect[1].g_h = hd/2;
  721.  
  722.          pos.rect[2].g_x = xd;
  723.          pos.rect[2].g_y = yd+hd/2;
  724.          pos.rect[2].g_w = wd/2;
  725.          pos.rect[2].g_h = hd/2;
  726.  
  727.          pos.rect[3].g_x = xd+wd/2;
  728.          pos.rect[3].g_y = yd;
  729.          pos.rect[3].g_w = wd/2;
  730.          pos.rect[3].g_h = hd/2;
  731.  
  732.          pos.rect[4].g_x = xd+wd/2;
  733.          pos.rect[4].g_y = yd+hd/2;
  734.          pos.rect[4].g_w = wd/2;
  735.          pos.rect[4].g_h = hd/2;
  736.  
  737.          break;
  738.       case 5:
  739.          pos.rect[1].g_x = xd;
  740.          pos.rect[1].g_y = yd;
  741.          pos.rect[1].g_w = wd/2;
  742.          pos.rect[1].g_h = hd/2;
  743.  
  744.          pos.rect[2].g_x = xd;
  745.          pos.rect[2].g_y = yd+hd/2;
  746.          pos.rect[2].g_w = wd/2;
  747.          pos.rect[2].g_h = hd/2;
  748.  
  749.          pos.rect[3].g_x = xd+wd/2;
  750.          pos.rect[3].g_y = yd;
  751.          pos.rect[3].g_w = wd/2;
  752.          pos.rect[3].g_h = hd/3;
  753.  
  754.          pos.rect[4].g_x = xd+wd/2;
  755.          pos.rect[4].g_y = yd+hd/3;
  756.          pos.rect[4].g_w = wd/2;
  757.          pos.rect[4].g_h = hd/3;
  758.  
  759.          pos.rect[5].g_x = xd+wd/2;
  760.          pos.rect[5].g_y = yd+2*hd/3;
  761.          pos.rect[5].g_w = wd/2;
  762.          pos.rect[5].g_h = hd/3;
  763.  
  764.          break;
  765.       case 6:
  766.          pos.rect[1].g_x = xd;
  767.          pos.rect[1].g_y = yd;
  768.          pos.rect[1].g_w = wd/2;
  769.          pos.rect[1].g_h = hd/3;
  770.  
  771.          pos.rect[2].g_x = xd;
  772.          pos.rect[2].g_y = yd+hd/3;
  773.          pos.rect[2].g_w = wd/2;
  774.          pos.rect[2].g_h = hd/3;
  775.  
  776.          pos.rect[3].g_x = xd;
  777.          pos.rect[3].g_y = yd+2*hd/3;
  778.          pos.rect[3].g_w = wd/2;
  779.          pos.rect[3].g_h = hd/3;
  780.  
  781.          pos.rect[4].g_x = xd+wd/2;
  782.          pos.rect[4].g_y = yd;
  783.          pos.rect[4].g_w = wd/2;
  784.          pos.rect[4].g_h = hd/3;
  785.  
  786.          pos.rect[5].g_x = xd+wd/2;
  787.          pos.rect[5].g_y = yd+hd/3;
  788.          pos.rect[5].g_w = wd/2;
  789.          pos.rect[5].g_h = hd/3;
  790.  
  791.          pos.rect[6].g_x = xd+wd/2;
  792.          pos.rect[6].g_y = yd+2*hd/3;
  793.          pos.rect[6].g_w = wd/2;
  794.          pos.rect[6].g_h = hd/3;
  795.  
  796.          break;
  797.       case 7:
  798.          pos.rect[1].g_x = xd;
  799.          pos.rect[1].g_y = yd;
  800.          pos.rect[1].g_w = wd/2;
  801.          pos.rect[1].g_h = hd/3;
  802.  
  803.          pos.rect[2].g_x = xd;
  804.          pos.rect[2].g_y = yd+hd/3;
  805.          pos.rect[2].g_w = wd/2;
  806.          pos.rect[2].g_h = hd/3;
  807.  
  808.          pos.rect[3].g_x = xd;
  809.          pos.rect[3].g_y = yd+2*hd/3;
  810.          pos.rect[3].g_w = wd/2;
  811.          pos.rect[3].g_h = hd/3;
  812.  
  813.          pos.rect[4].g_x = xd+wd/2;
  814.          pos.rect[4].g_y = yd;
  815.          pos.rect[4].g_w = wd/2;
  816.          pos.rect[4].g_h = hd/4;
  817.  
  818.          pos.rect[5].g_x = xd+wd/2;
  819.          pos.rect[5].g_y = yd+hd/4;
  820.          pos.rect[5].g_w = wd/2;
  821.          pos.rect[5].g_h = hd/4;
  822.  
  823.          pos.rect[6].g_x = xd+wd/2;
  824.          pos.rect[6].g_y = yd+2*hd/4;
  825.          pos.rect[6].g_w = wd/2;
  826.          pos.rect[6].g_h = hd/4;
  827.  
  828.          pos.rect[7].g_x = xd+wd/2;
  829.          pos.rect[7].g_y = yd+3*hd/4;
  830.          pos.rect[7].g_w = wd/2;
  831.          pos.rect[7].g_h = hd/4;
  832.  
  833.          break;
  834.    }
  835.    for(i=1, k=1; i<MAXWINDOWS; i++)
  836.       if(_wind[i].w_state & CREATED && _wind[i].w_state & OPENED)
  837.          if(pos.rect[k].g_w && pos.rect[k].g_h)
  838.             Wmovesize(&_wind[i],&pos.rect[k++]);
  839. }
  840.  
  841. void Warrange(int how)
  842. {
  843.     GRECT grect;
  844.     int i,k,count,xstep,ystep,diff;
  845. /*
  846.     int msgbuf[8];
  847. */    
  848.     if(how==1)
  849.     {
  850.         _Wtile();
  851.         return;
  852.     }
  853.  
  854.     count = Wcount(OPENED);
  855.     if(count>1)
  856.     {
  857.         xstep = w_desk/count;
  858.         diff=(count-1)*xstep+MIN_WIDTH - w_desk;
  859.         if(diff>0)
  860.             xstep-=diff/count;
  861.  
  862.         ystep = h_desk/count;
  863.         diff=(count-1)*ystep+MIN_HEIGHT - h_desk;
  864.         if(diff>0)
  865.             ystep-=diff/count;
  866.  
  867.         for(i=1, k=0; i<MAXWINDOWS; i++)
  868.             if((_wind[i].w_state & CREATED) && (_wind[i].w_state & OPENED))
  869.             {
  870.                 switch(how)
  871.                 {
  872.                     case 1: /* untereinander */
  873.                         grect.g_x = x_desk;
  874.                         grect.g_y = k * ystep + y_desk;
  875.                         grect.g_w = w_desk;
  876.                         grect.g_h = ystep;
  877.                         break;
  878.                     case 2: /* nebeneinander */
  879.                         grect.g_x = k * xstep + x_desk;
  880.                         grect.g_y = y_desk;
  881.                         grect.g_w = xstep;
  882.                         grect.g_h = h_desk;
  883.                         break;
  884.                     case 3: /* überlappend */
  885.                         grect.g_x = k * y_desk + x_desk;
  886.                         grect.g_y = k * y_desk + y_desk;
  887.                         grect.g_w = w_desk-(count-1)*y_desk;
  888.                         grect.g_h = h_desk-(count-1)*y_desk;
  889.                         break;
  890.                 }
  891.                 Wmovesize(&_wind[i],(int *)&grect);
  892.                 Wtop(&_wind[i]);
  893.                 k++;
  894.             }
  895.     }
  896.     else
  897.         Wfull(Wgettop());
  898. }
  899.  
  900. /*
  901. /* 11.9.1993 */
  902. void Wiconify(WINDOW *wp, int nxywh[])
  903. {
  904.     if(wp)
  905.     {
  906. /*
  907.       Wmovesize(wp, nxywh);
  908. */
  909.         graf_shrinkbox(nxywh[0],nxywh[1],nxywh[2],nxywh[3],
  910.                   wp->xwork, wp->ywork,
  911.                 wp->wwork, wp->hwork);
  912.       wind_set(wp->wihandle, 
  913.                WF_ICONIFY,
  914.                nxywh[0],nxywh[1],nxywh[2],nxywh[3]);
  915.         
  916.       _wind_get(wp->wihandle, WF_WORKXYWH,
  917.                  &wp->xwork, &wp->ywork,
  918.                &wp->wwork, &wp->hwork);
  919.  
  920.         graf_mouse(M_OFF,0L);
  921.         Wcursor(wp);
  922.         Wcuroff(wp);
  923.         graf_mouse(M_ON,0L);
  924.         wp->w_state |= ICONIFIED;
  925.     }
  926. }
  927.  
  928. void Wuniconify(WINDOW *wp, int nxywh[])
  929. {
  930.     if(wp)
  931.     {
  932. /*
  933.       Wmovesize(wp, nxywh);
  934. */
  935.         graf_growbox(wp->xwork, wp->ywork,
  936.                    wp->wwork, wp->hwork,
  937.                    nxywh[0],nxywh[1],nxywh[2],nxywh[3]);
  938.  
  939.       wind_set(wp->wihandle, 
  940.                WF_UNICONIFY,
  941.                nxywh[0],nxywh[1],nxywh[2],nxywh[3]);
  942.  
  943.       _wind_get(wp->wihandle, WF_WORKXYWH,
  944.                  &wp->xwork, &wp->ywork,
  945.                &wp->wwork, &wp->hwork);
  946.  
  947.         graf_mouse(M_OFF,0L);
  948.         Wcuron(wp);
  949.         Wcursor(wp);
  950.         graf_mouse(M_ON,0L);
  951.         wp->w_state &= ~ICONIFIED;
  952.     }
  953. }
  954. */
  955. void Wcycle(register WINDOW *wp)
  956. {
  957.     register int i,k;
  958.  
  959.     if(wp)
  960.     {
  961.         for(i=1,k=1; i<MAXWINDOWS; i++,k++)
  962.             if(_wind[i].wihandle==wp->wihandle)
  963.                 break;
  964.         for(++i; i<MAXWINDOWS; i++)
  965.             if(_wind[i].w_state & OPENED)
  966.             {
  967.                 Wtop(&_wind[i]);
  968.                 return;
  969.             }
  970.         for(i=1; i<k; i++)
  971.             if(_wind[i].w_state & OPENED)
  972.             {
  973.                 Wtop(&_wind[i]);
  974.                 return;
  975.             }
  976.     }
  977. }
  978.  
  979. int Wcount(int state)
  980. {
  981.     int i,count=0;
  982.     for(i=1; i<MAXWINDOWS; i++)
  983.         if(_wind[i].w_state & state)
  984.             count++;
  985.     return(count);
  986. }
  987.  
  988. static void _Wscroll(register WINDOW *wp, int dir, int delta, GRECT *rect)
  989. {
  990.   register int x, y, w, h;
  991.   FDB s, d;
  992.   register int pxyarray[8];
  993.  
  994.   x = rect->g_x; /* Arbeitsbereich */
  995.   y = rect->g_y;
  996.   w = rect->g_w;
  997.   h = rect->g_h;
  998.  
  999.   s.fd_addr = 0x0L;
  1000.   d.fd_addr = 0x0L;
  1001.  
  1002.   pxyarray [0] = x;
  1003.   pxyarray [1] = y;
  1004.   pxyarray [2] = x+w-1;
  1005.   pxyarray [3] = y+h-1;
  1006.   vs_clip(wp->vdihandle,TRUE,pxyarray);
  1007.  
  1008.   if (dir & VERTICAL)                                         /* Vertikales Scrolling */
  1009.   {
  1010.      if(h>abs(delta) && h>wp->hscroll)                                        /* Bereich kleiner delta */
  1011.      {
  1012.         if (delta > 0)                                             /* Aufwärts Scrolling */
  1013.         {
  1014.           pxyarray [0] = x;                                     /* Werte für vro_cpyfm */
  1015.           pxyarray [1] = y + delta;
  1016.           pxyarray [2] = x + w - 1;
  1017.           pxyarray [3] = y + h - 1;
  1018.           pxyarray [4] = x;
  1019.           pxyarray [5] = y;
  1020.           pxyarray [6] = pxyarray [2];
  1021.           pxyarray [7] = pxyarray [3] - delta;
  1022.  
  1023.           y = y + h - delta;              /* Unterer Bereich nicht gescrollt,... */
  1024.           h = delta;                                  /* ...muß neu gezeichnet werden */
  1025.         }                                                /* Es muß mehr gezeichnet werden */
  1026.         else                                                            /* Abwärts Scrolling */
  1027.         {
  1028.           pxyarray [0] = x;                                     /* Werte für vro_cpyfm */
  1029.           pxyarray [1] = y;
  1030.           pxyarray [2] = x + w - 1;
  1031.           pxyarray [3] = y + h + delta - 1;
  1032.           pxyarray [4] = x;
  1033.           pxyarray [5] = y - delta;
  1034.           pxyarray [6] = pxyarray [2];
  1035.           pxyarray [7] = pxyarray [3] - delta;
  1036.  
  1037.           h = -delta;                            /* Oberen Bereich noch neu zeichnen */
  1038.         }
  1039.         vro_cpyfm(wp->vdihandle, 3, pxyarray, &s, &d);/* Eigentliches Scrolling */
  1040.         pxyarray[0] = x;                                 /* neuzuzeichnendes Rechteck */
  1041.         pxyarray[1] = y;
  1042.         pxyarray[2] = x+w-1;
  1043.         pxyarray[3] = y+h-1;
  1044.      }
  1045.   }
  1046.   else                                                          /* Horizontales Scrolling */
  1047.   {
  1048.      if(w>abs(delta) && w>wp->wscroll)                                        /* Bereich kleiner delta */
  1049.      {
  1050.         if (delta > 0)                                                 /* Links Scrolling */
  1051.         {
  1052.           pxyarray [0] = x + delta;                          /* Werte für vro_cpyfm */
  1053.           pxyarray [1] = y;
  1054.           pxyarray [2] = x + w - 1;
  1055.           pxyarray [3] = y + h - 1;
  1056.           pxyarray [4] = x;
  1057.           pxyarray [5] = y;
  1058.           pxyarray [6] = pxyarray [2] - delta;
  1059.           pxyarray [7] = pxyarray [3];
  1060.  
  1061.           x = x + w - delta;              /* Rechter Bereich nicht gescrollt,... */
  1062.           w = delta;                                  /* ...muß neu gezeichnet werden */
  1063.         }                                                /* Es muß mehr gezeichnet werden */
  1064.         else                                                             /* Rechts Scrolling */
  1065.         {
  1066.           pxyarray [0] = x;                                     /* Werte für vro_cpyfm */
  1067.           pxyarray [1] = y;
  1068.           pxyarray [2] = x + w + delta - 1;
  1069.           pxyarray [3] = y + h - 1;
  1070.           pxyarray [4] = x - delta;
  1071.           pxyarray [5] = y;
  1072.           pxyarray [6] = pxyarray [2] - delta;
  1073.           pxyarray [7] = pxyarray [3];
  1074.  
  1075.           w = -delta;                            /* Linken Bereich noch neu zeichnen */
  1076.         }
  1077.         vro_cpyfm(wp->vdihandle, 3, pxyarray, &s, &d);/* Eigentliches Scrolling */
  1078.         pxyarray[0] = x;                                 /* neuzuzeichnendes Rechteck */
  1079.         pxyarray[1] = y;
  1080.         pxyarray[2] = x+w-1;
  1081.         pxyarray[3] = y+h-1;
  1082.      }
  1083.   }
  1084.   vs_clip(wp->vdihandle,TRUE,pxyarray);
  1085.   wp->draw(wp,dir,pxyarray);
  1086.   return;
  1087. }
  1088.  
  1089. void Wscroll(register WINDOW *wp, int dir, int delta, GRECT *rect)
  1090. {
  1091.     int area[4];
  1092. #if MiNT
  1093.     wind_update(BEG_UPDATE);
  1094. #endif
  1095.     _wind_get(wp->wihandle, WF_FIRSTXYWH, &area[0], &area[1], &area[2], &area[3]);
  1096.     while( area[2] && area[3] )
  1097.     {
  1098.         if(rc_intersect(&x_desk,area))
  1099.         {
  1100.             if(rc_intersect(rect,area))
  1101.             {
  1102.                 _Wscroll(wp,dir,delta,area);
  1103.             }
  1104.         }
  1105.         _wind_get(wp->wihandle, WF_NEXTXYWH, &area[0], &area[1], &area[2], &area[3]);
  1106.     }
  1107. #if MiNT
  1108.     wind_update(END_UPDATE);
  1109. #endif
  1110. }
  1111.  
  1112. void Wslide(register WINDOW *wp, int newslide, int which)
  1113. {
  1114.     register long newpos,i,delta;
  1115. /*
  1116.     int area[4];
  1117. */
  1118.     if(wp->kind & VSLIDE & which)
  1119.     {
  1120.         newpos=(long)newslide*(wp->hsize-wp->hwork)/1000L;
  1121.         newpos-=(newpos%wp->hscroll);
  1122.         delta=newpos-wp->hfirst;
  1123.         if(delta)
  1124.         {
  1125.             wp->hfirst=newpos;
  1126.             if(delta > 0)
  1127.             {
  1128.                 for(i=0; i<delta/wp->hscroll; i++)
  1129.                 {
  1130.                     wp->wstr=wp->wstr->next;
  1131.                     wp->cstr=wp->cstr->next;
  1132.                 }
  1133.             }
  1134.             else
  1135.             {
  1136.                 for(i=0; i<(-delta/wp->hscroll); i++)
  1137.                 {
  1138.                     wp->wstr=wp->wstr->prev;
  1139.                     wp->cstr=wp->cstr->prev;
  1140.                 }
  1141.             }
  1142.             if(labs(delta) >= wp->hwork)
  1143.             {
  1144.                 Wredraw(wp, &wp->xwork);     /* Bereich ganz neu zeichnen */
  1145.             }
  1146.             else
  1147.             {
  1148.                 Wscroll(wp,VERTICAL,delta,&wp->xwork);
  1149.             }
  1150.         }
  1151.     }
  1152.     if(wp->kind & HSLIDE & which)
  1153.     {
  1154.         newpos=(long)newslide*(wp->wsize-wp->wwork)/1000L;
  1155.         newpos-=(newpos%wp->wscroll);
  1156.         delta=newpos-wp->wfirst;
  1157.         if(delta)
  1158.         {
  1159.             wp->wfirst=newpos;                 /*-newpos%wp->wscroll;*/
  1160.             if(labs(delta) >= wp->wwork)
  1161.             {
  1162.                 Wredraw(wp, &wp->xwork);     /* Bereich ganz neu zeichnen */
  1163.             }
  1164.             else
  1165.             {
  1166.                 Wscroll(wp,HORIZONTAL,delta,&wp->xwork);
  1167.             }
  1168.         }
  1169.     }
  1170.     Wslupdate(wp,1+2+4+8);
  1171. }
  1172.  
  1173. int Warrow(register WINDOW *wp, int arrow)
  1174. {
  1175.     register long newpos,oldpos,i,delta=0;
  1176. /*
  1177.     int area[4];
  1178. */
  1179.     if(arrow<=WA_DNLINE)
  1180.     {
  1181.         oldpos=newpos=wp->hfirst;
  1182.         switch(arrow)
  1183.         {
  1184.             case WA_UPPAGE /*0*/:
  1185.                 if((newpos-=wp->hwork) < 0)
  1186.                     newpos=0;
  1187.                 break;
  1188.             case WA_DNPAGE /*1*/:
  1189.                 if((newpos+=wp->hwork) > (wp->hsize-wp->hwork))
  1190.                     newpos=wp->hsize-wp->hwork;
  1191.                 break;
  1192.             case WA_UPLINE /*2*/:
  1193.                 if(wp->hsize > wp->hwork)
  1194.                 {
  1195.                     if((newpos-=wp->hscroll) < 0)
  1196.                         newpos=0;
  1197.                     if(++wp->row > wp->hwork/wp->hscroll-1)
  1198.                         wp->row=wp->hwork/wp->hscroll-1;
  1199.                 }
  1200.                 break;
  1201.             case WA_DNLINE /*3*/:
  1202.                 if(wp->hsize > wp->hwork)
  1203.                 {
  1204.                     if((newpos+=wp->hscroll) > (wp->hsize-wp->hwork))
  1205.                         newpos=wp->hsize-wp->hwork;
  1206.                     if(--wp->row < 0)
  1207.                         wp->row=0;
  1208.                 }
  1209.                 break;
  1210.         }
  1211.         wp->hfirst=newpos;
  1212.         delta=newpos-oldpos;
  1213.         if(delta)
  1214.         {
  1215.             if(delta > 0)
  1216.             {
  1217.                 for(i=0; i<delta/wp->hscroll; i++)
  1218.                 {
  1219.                     wp->wstr=wp->wstr->next;
  1220.                 }
  1221.             }
  1222.             else
  1223.             {
  1224.                 for(i=0; i<(-delta/wp->hscroll); i++)
  1225.                 {
  1226.                     wp->wstr=wp->wstr->prev;
  1227.                 }
  1228.             }
  1229.             wp->cstr=wp->wstr;
  1230.             for(i=0; i<wp->row; i++)
  1231.             {
  1232.                 wp->cstr=wp->cstr->next;
  1233.             }
  1234.             if(labs(delta) >= wp->hwork)
  1235.             {
  1236.                 Wredraw(wp, &wp->xwork);     /* Bereich ganz neu zeichnen */
  1237.             }
  1238.             else
  1239.             {
  1240.                 Wscroll(wp,VERTICAL,delta,&wp->xwork);
  1241.             }
  1242.             return((int)delta);
  1243.         }
  1244.     }
  1245.     else
  1246.     {
  1247.         oldpos=newpos=wp->wfirst;
  1248.         switch(arrow)
  1249.         {
  1250.             case WA_LFPAGE /*4*/:
  1251.                 if((newpos-=wp->wwork) < 0)
  1252.                     newpos=0;
  1253.                 break;
  1254.             case WA_RTPAGE /*5*/:
  1255.                 if((newpos+=wp->wwork) > (wp->wsize-wp->wwork))
  1256.                     newpos=wp->wsize-wp->wwork;
  1257.                 break;
  1258.             case WA_LFLINE /*6*/:
  1259.                 if(wp->wsize > wp->wwork)
  1260.                     if((newpos-=(HORIZ_OFFSET*wp->wscroll)) < 0)
  1261.                         newpos=0;
  1262.                     else
  1263.                         wp->cspos=(wp->col+=HORIZ_OFFSET);
  1264.                 break;
  1265.             case WA_RTLINE /*7*/:
  1266.                 if(wp->wsize > wp->wwork)
  1267.                     if((newpos+=(HORIZ_OFFSET*wp->wscroll)) > (wp->wsize-wp->wwork))
  1268.                         newpos=wp->wsize-wp->wwork;
  1269.                     else
  1270.                         wp->cspos=(wp->col-=HORIZ_OFFSET);
  1271.                 break;
  1272.         }
  1273.         wp->wfirst=newpos;
  1274.         delta=newpos-oldpos;
  1275.         if(delta)
  1276.         {
  1277.             if(labs(delta) >= wp->wwork)
  1278.             {
  1279.                 Wredraw(wp, &wp->xwork);     /* Bereich ganz neu zeichnen */
  1280.             }
  1281.             else
  1282.             {
  1283.                 Wscroll(wp,HORIZONTAL,delta,&wp->xwork);
  1284.             }
  1285.             return((int)delta);
  1286.         }
  1287.     }
  1288.     return(0);
  1289. }
  1290. /*
  1291. int _Warrow(register WINDOW *wp, int mesag[])
  1292. {
  1293.    register int scrollx, scrolly, speed, linesperpage, columnsperpage;
  1294.    if(wp)
  1295.    {
  1296.       if((mesag[ 5] < 0) || (mesag[ 7] < 0))
  1297.       {
  1298.           linesperpage=wp->hwork/wp->hscroll;
  1299.           columnsperpage=wp->wwork/wp->wscroll;
  1300.           scrollx = scrolly = 0;
  1301.           speed = (mesag[ 5] < 0) ? -mesag[ 5] : 1;
  1302.           switch (mesag[ 4]) 
  1303.           {
  1304.              case WA_UPLINE: scrolly = -speed; break;
  1305.              case WA_DNLINE: scrolly = speed; break;
  1306.               case WA_LFLINE: scrollx = -speed; break;
  1307.               case WA_RTLINE: scrollx = speed; break;
  1308.               case WA_UPPAGE: scrolly = -(speed * linesperpage); break;
  1309.               case WA_DNPAGE: scrolly = (speed * linesperpage); break;
  1310.               case WA_LFPAGE: scrollx = -(speed * columnsperpage); break;
  1311.               case WA_RTPAGE: scrollx = (speed * columnsperpage); break;
  1312.           }
  1313.           if (mesag[ 7] < 0) 
  1314.           {
  1315.              speed = -mesag[ 7];
  1316.              switch (mesag[ 6]) 
  1317.              {
  1318.                 case WA_UPLINE: scrolly = scrolly - speed; break;
  1319.                 case WA_DNLINE: scrolly = scrolly + speed; break;
  1320.                 case WA_LFLINE: scrollx = scrollx - speed; break;
  1321.                 case WA_RTLINE: scrollx = scrollx + speed; break;
  1322.                 case WA_UPPAGE: scrolly = scrolly - (speed * linesperpage); break;
  1323.                 case WA_DNPAGE: scrolly = scrolly + (speed * linesperpage); break;
  1324.                 case WA_LFPAGE: scrollx = scrollx - (speed * columnsperpage); break;
  1325.                 case WA_RTPAGE: scrollx = scrollx + (speed * columnsperpage); break;
  1326.              }
  1327.           }
  1328. /*
  1329.           if (scrollx != 0) 
  1330.             Wscroll(wp, HORIZONTAL, scrollx * wp->wscroll, &wp->xwork)
  1331.           if (scrolly != 0)
  1332.             Wscroll(wp, VERTICAL, scrolly * wp->hscroll, &wp->xwork)
  1333. */
  1334.           if (scrollx != 0) 
  1335.             Warrow(wp, msgbuf, scrollx);
  1336.           if (scrolly != 0)
  1337.             Warrow(wp, msgbuf, scrolly);
  1338.         }
  1339.         else
  1340.             Warrow(wp, mesag[ 4]);
  1341.    }
  1342. }
  1343. */
  1344. void Wslupdate(register WINDOW *wp, int what)
  1345. {
  1346.     register long newpos;
  1347.     int slider,ret;
  1348.  
  1349.     if(wp)
  1350.     {
  1351.         if((wp->kind & HSLIDE) && (what & 4))
  1352.         {
  1353.             _wind_get(wp->wihandle,WF_HSLSIZE,&slider,&ret,&ret,&ret);
  1354.             newpos=1000L*wp->wwork/notnull(wp->wsize);
  1355.             if((slider == 1000 && newpos < slider) ||
  1356.                 (slider <  1000 && newpos != slider))
  1357.                 wind_set(wp->wihandle,WF_HSLSIZE,(int)min(1000,newpos),0,0,0);
  1358.         }
  1359.         if((wp->kind & VSLIDE) && (what & 8))
  1360.         {
  1361.             _wind_get(wp->wihandle,WF_VSLSIZE,&slider,&ret,&ret,&ret);
  1362.             newpos=1000L*wp->hwork/notnull(wp->hsize);
  1363.             if((slider == 1000 && newpos < slider) ||
  1364.                 (slider <  1000 && newpos != slider))
  1365.                 wind_set(wp->wihandle,WF_VSLSIZE,(int)min(1000,newpos),0,0,0);
  1366.         }
  1367.         if((wp->kind & HSLIDE) && (what & 1))
  1368.         {
  1369.             if((newpos=(int)((1000L*wp->wfirst)/notnull(wp->wsize-wp->wwork)))!=wp->slwpos)
  1370.                 wind_set(wp->wihandle,WF_HSLIDE,wp->slwpos=newpos,0,0,0);
  1371.         }
  1372.         if((wp->kind & VSLIDE) && (what & 2))
  1373.         {
  1374.             if((newpos=(int)((1000L*wp->hfirst)/notnull(wp->hsize-wp->hwork)))!=wp->slhpos)
  1375.                 wind_set(wp->wihandle,WF_VSLIDE,wp->slhpos=newpos,0,0,0);
  1376.         }
  1377.     }
  1378. }
  1379.  
  1380. void Wclose(register WINDOW *wp)
  1381. {
  1382.     int x,y,w,h,xi,yi,wi,hi;
  1383.  
  1384.     if(wp && wp->w_state & OPENED)
  1385.     {
  1386.         _wind_get(wp->wihandle,WF_CURRXYWH,&x,&y,&w,&h);
  1387.         wind_close(wp->wihandle);
  1388.         iconposition(Wh(wp),&xi,&yi,&wi,&hi);
  1389.         graf_shrinkbox(xi,yi,wi,hi,x,y,w,h);
  1390.         wp->w_state &= ~OPENED;
  1391.         wp->w_state &= ~ONTOP;
  1392. #if GEMDOS
  1393.         AVAccClosedWindow(wp->wihandle);
  1394. #endif
  1395.         if(wp=Wgettop())
  1396.         {
  1397.             Wfindblk(wp,&blkwp,&begcut,&endcut);
  1398.         }
  1399.     }
  1400. }
  1401.  
  1402. void Wopenall(void)
  1403. {
  1404.     register int i;
  1405.  
  1406.     for(i=1; i<MAXWINDOWS; i++)
  1407.         if(_wind[i].w_state & CREATED && !(_wind[i].w_state & OPENED))
  1408.             Wopen(&_wind[i]);
  1409. }
  1410.  
  1411. void Wcloseall(void)
  1412. {
  1413.     register int i;
  1414.  
  1415.     for(i=1; i<MAXWINDOWS; i++)
  1416.         if(_wind[i].w_state & OPENED)
  1417.             Wclose(&_wind[i]);
  1418. }
  1419.  
  1420. void Wreset(WINDOW *wp)
  1421. {
  1422.     if(wp)
  1423.     {
  1424.         wp->wihandle  = NOWINDOW;
  1425.         wp->vdihandle = 0;
  1426.         wp->icon        = 0;
  1427.         wp->kind        = 0;
  1428.         wp->w_state    &= ~CREATED;
  1429.         wp->w_state    &= ~OPENED;
  1430.         wp->w_state    &= ~FULLED;
  1431.         wp->w_state    &= ~ONTOP;
  1432.         wp->w_state    &= ~CURSOR;
  1433.         wp->w_state    &= ~CHANGED;
  1434.         wp->w_state    &= ~CURSON;
  1435.         wp->w_state    &= ~GEMFONTS;
  1436.         wp->w_state    &= ~PROPFONT;
  1437.         wp->w_state    &= ~CBLINK;
  1438.         wp->type        = 0;
  1439.         wp->hfirst/=wp->hscroll;     /* in Zeilenzahl umwandeln */
  1440.         wp->wfirst/=wp->wscroll;
  1441.         wp->hsize      = 0;
  1442.         wp->wsize      = 0;
  1443.         wp->slhpos     = 0;
  1444.         wp->slwpos     = 0;
  1445.         wp->draw        = Wclear;
  1446.         wp->outspec    = 0L;
  1447.         wp->fstr=wp->wstr=wp->cstr=0L;
  1448.         wp->toolbar=NULL;
  1449.         wp->toolbaraddress=0L;
  1450.         wp->tabbar =NULL;
  1451.     }
  1452. }
  1453.  
  1454. void Wdelete(register WINDOW *wp)
  1455. {
  1456.     WORD obj;
  1457.     OBJECT *ob;
  1458.  
  1459.     if(wp)
  1460.     {
  1461.         if(wp->w_state & OPENED)
  1462.             Wclose(wp);
  1463.         if(wp->w_state & CREATED)
  1464.         {
  1465.             free(wp->name);
  1466.             wp->name=NULL;
  1467.             free(wp->info);
  1468.             wp->info=NULL;
  1469.             wind_delete(wp->wihandle);
  1470.             close_work(wp->vdihandle,SCREEN);
  1471.             if(wp->toolbar && wp->toolbaraddress)
  1472.             {    
  1473.                 obj = 0;
  1474.                do 
  1475.                {
  1476.                     ob = &wp->toolbar[++obj];
  1477.                     if(ob->ob_type==G_USERDEF)
  1478.                         free((char *)((TEDINFO *)ob->ob_spec.userblk->ub_parm)->te_ptext);
  1479.                    if(EXOB_TYPE(ob->ob_type)==0xFF)
  1480.                         free(ob->ob_spec.tedinfo->te_ptext);
  1481.                 } 
  1482.                 while (! (ob->ob_flags & LASTOB));
  1483.  
  1484.                 /* Register für rsrc_free() setzen */
  1485.                 *(long *)&_GemParBlk.global[7]=wp->toolbaraddress;
  1486.                 rsrc_free();
  1487.             }
  1488.             Wreset(wp);
  1489.         }
  1490.     }
  1491. }
  1492.  
  1493. void Wnew(void) /* neu: MT 22.9.94 */
  1494. {
  1495.     register int i;
  1496.     int wh;
  1497.     WINDOW *wp;
  1498. #if GEMDOS
  1499.     if(_GemParBlk.global[0]>=0x0140)
  1500.     {
  1501.         for(i=1; i<MAXWINDOWS; i++)
  1502.             if(_wind[i].w_state & CREATED)
  1503.             {
  1504.                 wp=Wp(_wind[i].wihandle);
  1505.                 Wfree(wp);
  1506.                 if(wp->w_state&OPENED)
  1507.                     AVAccClosedWindow(wp->wihandle);
  1508.                 
  1509.                 if(wp->toolbar)
  1510.                 {    
  1511.                   /* Register für rsrc_free() setzen */
  1512.                     *(long *)&_GemParBlk.global[7]=wp->toolbaraddress;
  1513.                     rsrc_free();
  1514.                 }
  1515.                 if(_GemParBlk.global[1] == 1) /* Singletasking */
  1516.                     wind_delete(wp->wihandle);
  1517.                 close_work(wp->vdihandle,SCREEN);
  1518.                 Wreset(wp);
  1519.             }
  1520.         if(_GemParBlk.global[1] != 1) /* Multitasking */
  1521.             wind_new();
  1522.     }
  1523.     else
  1524. #endif
  1525.     {
  1526.         for(i=1; i<MAXWINDOWS; i++)
  1527.             if(_wind[i].w_state & CREATED)
  1528.             {
  1529.                 Wfree(Wp(_wind[i].wihandle));
  1530.                 Wdelete(Wp(_wind[i].wihandle));
  1531.             }
  1532.      }
  1533. }
  1534. /*
  1535. void Wnew(void)
  1536. {
  1537.     register int i;
  1538.     int wh;
  1539.     WINDOW *wp;
  1540. #if GEMDOS
  1541.     if(_GemParBlk.global[0]>=0x0140)
  1542.     {
  1543.         for(i=1; i<MAXWINDOWS; i++)
  1544.             if(_wind[i].w_state & CREATED)
  1545.             {
  1546.                 wp=Wp(_wind[i].wihandle);
  1547.                 Wfree(wp);
  1548.                 if(wp->w_state&OPENED)
  1549.                     AVAccClosedWindow(wp->wihandle);
  1550.                 close_work(wp->vdihandle,SCREEN);
  1551.                 Wreset(wp);
  1552.             }
  1553.        if( ! (get_cookie('MiNT') && 
  1554.           (_GemParBlk.global[0]>=0x0400) && 
  1555.           (_GemParBlk.global[1] != 1)))
  1556.             wind_update(BEG_UPDATE); /* wg. wind_new() */
  1557.         wind_new();
  1558.     }
  1559.     else
  1560. #endif
  1561.     {
  1562.         for(i=1; i<MAXWINDOWS; i++)
  1563.             if(_wind[i].w_state & CREATED)
  1564.             {
  1565.                 Wfree(Wp(_wind[i].wihandle));
  1566.                 Wdelete(Wp(_wind[i].wihandle));
  1567.             }
  1568.      }
  1569. }
  1570. */
  1571. extern int additional;
  1572.  
  1573. int Wsetscreen(WINDOW *wp)
  1574. {
  1575.     register long i,k;
  1576.     LINESTRUCT *help;
  1577.     int x,y,w,h;
  1578.     extern int boxh;
  1579.  
  1580. #if MSDOS
  1581.     void far *l;
  1582.     long size;
  1583. #endif
  1584.  
  1585.     if(wp)
  1586.     {
  1587.         if(wp->fontid==1)                    /* wenn Standardfont */
  1588.             Wnewfont(wp,1,wp->fontsize); /* letzte Fontgröße */
  1589.         else                                     /* sonst Fonts laden */
  1590.         {
  1591.             graf_mouse(BUSY_BEE,0L);
  1592.             vq_extnd(wp->vdihandle,0,work_out);
  1593. #if GEMDOS
  1594.             if(vq_gdos())
  1595.             {
  1596.                 additional=vst_load_fonts(wp->vdihandle,0)+work_out[10];
  1597.                 wp->w_state|=GEMFONTS;
  1598.             }
  1599.             else
  1600.                 additional=work_out[10]; /* Nur 6x6 system font */
  1601. #else
  1602.             size=farcoreleft()-64*1024L;
  1603.             if(size>0 && (l=farmalloc(size))!=NULL)     /*64*/
  1604.             {
  1605.                 additional=vst_ex_load_fonts(wp->vdihandle, 0, 4096, 0)+work_out[10]; /*4096*/
  1606.                 wp->w_state|=GEMFONTS;
  1607.                 farfree(l);
  1608.             }
  1609.             else
  1610.                 additional=work_out[10];
  1611. #endif
  1612.             graf_mouse(ARROW,0L);
  1613.  
  1614.             if(additional==work_out[10])     /* Fehler, kein Fontladen möglich */
  1615.             {
  1616.                 Wnewfont(wp,1,norm_point);  /* Standartfont bei Fehler */
  1617.                 wp->w_state&=~PROPFONT;
  1618.             }
  1619.             else
  1620.             {
  1621.                 if(wp->fontid==vst_font(wp->vdihandle,wp->fontid)) /* falls in ASSIGN.SYS etwas geändert wurde */
  1622.                     Wnewfont(wp,wp->fontid,wp->fontsize); /* letzter Font und Größe */
  1623.                 else
  1624.                     Wnewfont(wp,1,norm_point);  /* Standartfont bei Fehler */
  1625.             }
  1626.         }
  1627.         _wind_calc(wp->wihandle,WC_BORDER,wp->kind,wp->xwork,wp->ywork,wp->wwork,wp->hwork,
  1628.             &x,&y,&w,&h);
  1629.                                                                     /*MT 12.9.94 '<=' statt '<' */
  1630.         if(x<(x_desk+w_desk-1) && y<(y_desk+h_desk-1) && w<=w_desk && h<=h_desk)
  1631.         {
  1632.             help=wp->fstr;
  1633.             k=wp->hfirst;
  1634.             wp->hfirst*=wp->hscroll;          /* erweitern auf pixelformat */
  1635.             wp->wfirst*=wp->wscroll;
  1636.             for(i=0; i<k && help; i++, help=help->next)
  1637.                 ;
  1638.             if(help)
  1639.             {
  1640.                 wp->wstr=help;
  1641.                 k=wp->row;
  1642.                 for(i=0;
  1643.                      i<k && i<(wp->hwork/wp->hscroll-1) && help;
  1644.                      i++,help=help->next)
  1645.                     ;
  1646.                 if(help)
  1647.                 {
  1648.                     wp->cstr=help;
  1649.  
  1650.                     for(i;
  1651.                          i<k && wp->wstr->next && wp->cstr->next;
  1652.                          i++)
  1653.                     {
  1654.                         wp->wstr=wp->wstr->next;
  1655.                         wp->cstr=wp->cstr->next;
  1656.                         wp->hfirst+=wp->hscroll;
  1657.                     }
  1658.                     adjust_best_position(wp);
  1659.                     wp->col=wp->cspos;
  1660.                     return(TRUE);
  1661.                 }
  1662.             }
  1663.         }
  1664.         _wind_calc(wp->wihandle,WC_WORK,wp->kind,x_desk,y_desk,w_desk,h_desk,
  1665.             &wp->xwork,&wp->ywork,&wp->wwork,&wp->hwork);
  1666.         wp->xwork=align(wp->xwork,wp->wscroll);
  1667.         wp->wwork=align(wp->wwork,wp->wscroll);
  1668.         wp->hwork=align(wp->hwork,wp->hscroll);
  1669.         wp->xwork+=wp->wscroll; /* Fenster nicht ganz groß, wg. Cursor */
  1670.         wp->wwork-=wp->wscroll;
  1671.         wp->cstr=wp->wstr=wp->fstr;
  1672.         wp->hfirst=wp->wfirst=0;
  1673.         wp->cspos=wp->col=wp->row=0;
  1674.     }
  1675.     return(FALSE);
  1676. }
  1677.  
  1678. int Wblksize(WINDOW *wp, LINESTRUCT *beg, LINESTRUCT *end, long *lines, long *chars)
  1679. {
  1680.     register LINESTRUCT *line;
  1681.     if(wp && wp->fstr)
  1682.     {
  1683.         (*lines)=(*chars)=0;
  1684.         line=beg;
  1685.         do
  1686.         {
  1687.             (*lines)++;
  1688.             (*chars)+=min(line->used,line->endcol)-line->begcol;
  1689.             line=line->next;
  1690.         }
  1691.         while(line != end->next);
  1692.         return(TRUE);
  1693.     }
  1694.     return(FALSE);
  1695. }
  1696.  
  1697. int Wtxtsize(WINDOW *wp, long *lines, long *chars)
  1698. {
  1699.     register LINESTRUCT *line;
  1700.     if(wp && wp->fstr)
  1701.     {
  1702.         (*lines)=(*chars)=0;
  1703.         line=wp->fstr;
  1704.         do
  1705.         {
  1706.             (*lines)++;
  1707.             (*chars)+=line->used+2;
  1708.             line=line->next;
  1709.         }
  1710.         while(line);
  1711.         (*chars)-=2;
  1712.         return(TRUE);
  1713.     }
  1714.     return(FALSE);
  1715. }
  1716.  
  1717. WINDOW *Wgetwp(char *filename)
  1718. {
  1719.     register int i;
  1720.     for(i=1; i<MAXWINDOWS; i++)
  1721.         if((_wind[i].w_state & CREATED) && !strcmp((char *)Wname(&_wind[i]),filename))
  1722.             return(&_wind[i]);
  1723.     return((WINDOW *)0L);
  1724. }
  1725.  
  1726. WINDOW *Wp(int wh)
  1727. {
  1728.     register int i;
  1729.     for(i=1; i<MAXWINDOWS; i++)
  1730.         if((_wind[i].w_state&CREATED) && (wh==_wind[i].wihandle))
  1731.             return(&_wind[i]);
  1732.     return((WINDOW *)0L);
  1733. }
  1734.  
  1735. int Windex(WINDOW *wp)
  1736. {
  1737.     register int i;
  1738.     if(wp)
  1739.     {
  1740.         for(i=1; i<MAXWINDOWS; i++)
  1741.             if((wp->w_state&CREATED) && (wp->wihandle==_wind[i].wihandle))
  1742.                 return(i);
  1743.     }
  1744.     return(0);
  1745. }
  1746.  
  1747. WINDOW *Wmentry(int mentry)
  1748. {
  1749.     register int i;
  1750.     for(i=1; i<MAXWINDOWS; i++)
  1751.         if((_wind[i].w_state&CREATED) && (mentry==_wind[i].mentry))
  1752.             return(&_wind[i]);
  1753.     return((WINDOW *)0L);
  1754. }
  1755.  
  1756. WINDOW *Wicon(int icon)
  1757. {
  1758.     register int i;
  1759.     for(i=1; i<MAXWINDOWS; i++)
  1760.         if((_wind[i].w_state&CREATED) && (icon==_wind[i].icon))
  1761.             return(&_wind[i]);
  1762.     return((WINDOW *)0L);
  1763. }
  1764.  
  1765. int Wh(register WINDOW *wp)
  1766. {
  1767.     if(wp)
  1768.         return(wp->wihandle);
  1769.     else
  1770.         return(0);
  1771. }
  1772.  
  1773. WINDOW *Wgettop(void)
  1774. {
  1775.     WINDOW *wp=NULL;
  1776.     int wh,ret;
  1777.  
  1778.     _wind_get(0,WF_TOP,&wh,&ret,&ret,&ret);
  1779.     if(wp=Wp(wh))
  1780.         wp->w_state|=ONTOP;
  1781.     return(wp);
  1782. }
  1783.  
  1784. void Wclear(register WINDOW *wp)
  1785. {
  1786.     register int pxyarray[4];
  1787.     if(wp && wp->w_state & OPENED)
  1788.     {
  1789.         graf_mouse(M_OFF,0L);
  1790.         vswr_mode(wp->vdihandle,1);         /* überschreiben */
  1791.         vsf_interior(wp->vdihandle,1);     /* muster */
  1792.         vsf_color(wp->vdihandle,0);         /* farbe weiß */
  1793.         pxyarray[0]=wp->xwork;
  1794.         pxyarray[1]=wp->ywork;
  1795.         pxyarray[2]=wp->xwork + wp->wwork - 1;
  1796.         pxyarray[3]=wp->ywork + wp->hwork - 1;
  1797.         vr_recfl(wp->vdihandle,pxyarray); /* weißes rechteck in workspace */
  1798.         graf_mouse(M_ON,0L);
  1799.     }
  1800. }
  1801.  
  1802. #define C_Y 2
  1803. #define C_W 2
  1804. #define C_H 4
  1805. /*
  1806. #define C_Y 3
  1807. #define C_W 1
  1808. #define C_H 6
  1809. */
  1810. void Wcursor(register WINDOW *wp)
  1811. {
  1812.     register int pxyarray[4/*26*/],area[4],clip[4];
  1813.     register LINESTRUCT *line;
  1814.  
  1815.     if(!wp)
  1816.         return;
  1817.     if(!(wp->w_state & OPENED))
  1818.         return;
  1819.  
  1820.     wp->row=0;
  1821.     for(line = wp->wstr; line && line != wp->cstr; line = line->next)
  1822.         wp->row++;
  1823.  
  1824.     wp->col=wp->cspos; /* festen Cursor gewährleisten */
  1825.     if(!(wp->col + wp->wfirst/wp->wscroll < wp->cstr->used))
  1826.         wp->col = wp->cstr->used-wp->wfirst/wp->wscroll; /* max. an ende des strings */
  1827.     if(!(wp->w_state & CURSON))
  1828.         return;
  1829.     if(!(wp->w_state & CURSOR))
  1830.         return;
  1831.     if(wp->w_state&INSERT) /* INSERT */
  1832.     {
  1833. /*
  1834.         pxyarray[0]=max(wp->xwork,wp->xwork+wp->col*wp->wscroll - 1); /* Strichcursor */
  1835. */
  1836.         pxyarray[0]=wp->xwork+wp->col*wp->wscroll; /* Strichcursor */
  1837.         pxyarray[1]=wp->ywork+wp->row*wp->hscroll - C_Y;
  1838.         pxyarray[2]=C_W;
  1839.         pxyarray[3]=wp->hscroll + C_H;
  1840.         wp->w_state |= CBLINK;
  1841.     }
  1842.     else        /* OVERWRITE */
  1843.     {
  1844.         pxyarray[0]=wp->xwork+wp->col*wp->wscroll; /* Blockcursor */
  1845.         pxyarray[1]=wp->ywork+wp->row*wp->hscroll;
  1846.         pxyarray[2]=wp->wscroll;
  1847.         pxyarray[3]=wp->hscroll;
  1848.         wp->w_state &= ~CBLINK;
  1849.     }
  1850. #if MiNT
  1851.     wind_update(BEG_UPDATE);
  1852. #endif
  1853.     _wind_get(wp->wihandle, WF_FIRSTXYWH, &area[0], &area[1], &area[2], &area[3]);
  1854.     while( area[2] && area[3] )
  1855.     {
  1856.         if(rc_intersect(&x_desk,area))
  1857.         {
  1858.             if(rc_intersect(&wp->xwork,area)) /*4.6.94 wg. Toolbar*/
  1859.             {
  1860.                 if(rc_intersect(pxyarray,area))
  1861.                 {
  1862.                     clip[0]=area[0];
  1863.                     clip[1]=area[1];
  1864.                     clip[2]=area[0]+area[2]-1;
  1865.                     clip[3]=area[1]+area[3]-1;
  1866.  
  1867. /* überflüssig, ist doch ge-rc_intersect-et, leider nicht 18.3.95 */
  1868.                     vs_clip(vdihandle,TRUE,clip);
  1869.                     vr_recfl(vdihandle,clip); /* cursor ^ cursor  */
  1870.                 }
  1871.             }
  1872.         }
  1873.         _wind_get(wp->wihandle, WF_NEXTXYWH, &area[0], &area[1], &area[2], &area[3]);
  1874.     }
  1875. /*
  1876.     vs_clip(vdihandle,FALSE,clip);
  1877. */
  1878. #if MiNT
  1879.     wind_update(END_UPDATE);
  1880. #endif
  1881. }
  1882.  
  1883. int Wmxycursor(register WINDOW *wp,int mx,int my)
  1884. {
  1885.     register int i,newrow;
  1886.     if(wp)
  1887.     {
  1888.         if(mx >= wp->xwork &&
  1889.             mx <= (wp->xwork + wp->wwork -1) &&
  1890.             my >= wp->ywork &&
  1891.             my <= (wp->ywork + wp->hwork -1))
  1892.         {
  1893.             graf_mouse(M_OFF,0L);
  1894.             Wcursor(wp);
  1895.             wp->col=(mx-wp->xwork)/wp->wscroll;
  1896.             if(wp->w_state & INSERT)
  1897.                 if(((mx-wp->xwork) % wp->wscroll) >= wp->wscroll/2)
  1898.                     wp->col++;
  1899.             wp->cspos=wp->col;
  1900.             wp->row=(my-wp->ywork)/wp->hscroll;
  1901.             for(i=0,wp->cstr=wp->wstr;
  1902.                  i<wp->row && wp->cstr->next;
  1903.                  i++,wp->cstr=wp->cstr->next)
  1904.                 ;
  1905.             Wshiftpage(wp,0,wp->cstr->used);
  1906.             Wcuron(wp);
  1907.             Wcursor(wp);
  1908.             graf_mouse(M_ON,0L);
  1909.             return(TRUE);
  1910.         }
  1911.     }
  1912.     return(FALSE);
  1913. }
  1914.  
  1915. void _Wcblink(WINDOW *wp, int mx, int my)
  1916. {
  1917.     int hide=FALSE,pxyarray[8];
  1918.     if(wp && (wp->w_state & CURSOR) && (wp->w_state & CBLINK))
  1919.     {
  1920.         pxyarray[0]=mx-16;
  1921.         pxyarray[1]=my-16;
  1922.         pxyarray[2]=3*16;
  1923.         pxyarray[3]=3*16;
  1924.         pxyarray[4]=max(wp->xwork,wp->xwork+wp->col*wp->wscroll-1); /* Strichcursor */
  1925.         pxyarray[5]=wp->ywork+wp->row*wp->hscroll-2;
  1926.         pxyarray[6]=2;
  1927.         pxyarray[7]=wp->hscroll+4;
  1928.         if( rc_intersect(pxyarray,&pxyarray[4]))
  1929.         {
  1930.             hide=graf_mouse(M_OFF,0L);
  1931.         }
  1932.         if(wp->w_state & CURSON)
  1933.         {
  1934.             Wcursor(wp);
  1935.             wp->w_state &= ~CURSON;
  1936.         }
  1937.         else
  1938.         {
  1939.             wp->w_state |= CURSON;
  1940.             Wcursor(wp);
  1941.         }
  1942.         if(hide)
  1943.             graf_mouse(M_ON,0L);
  1944.     }
  1945. }
  1946.  
  1947. void Wcuron(register WINDOW *wp)
  1948. {
  1949.     if(wp)
  1950.     {
  1951.         wp->w_state |= CURSOR;
  1952.         wp->w_state |= CURSON;
  1953.     }
  1954. }
  1955.  
  1956. void Wcuroff(register WINDOW *wp)
  1957. {
  1958.     if(wp)
  1959.     {
  1960.         wp->w_state &= ~CURSOR;
  1961.         wp->w_state &= ~CURSON;
  1962.     }
  1963. }
  1964.  
  1965. int Wshiftpage(WINDOW *wp, int len, int used)
  1966. {
  1967.     register int abscol,pos;
  1968.     if(wp)
  1969.     {
  1970.         abscol=wp->col+wp->wfirst/wp->wscroll;
  1971.         abscol=min(abscol, used);
  1972.         abscol=max(0,abscol);
  1973.         if(((abscol-abs(len))<(int)(wp->wfirst/wp->wscroll) ||
  1974.              (abscol+abs(len))>(int)(wp->wfirst+wp->wwork)/wp->wscroll-1))
  1975.         {
  1976.             graf_mouse(M_OFF,NULL);
  1977.             pos=abscol+len;
  1978.             pos=max(0,pos);
  1979.             pos=min(pos,STRING_LENGTH);
  1980.             Wslide(wp,(int)(1000L*pos/STRING_LENGTH),HSLIDE);
  1981.     /*
  1982.             graf_mouse(M_ON,NULL);
  1983.     */
  1984.         }
  1985.         wp->col=abscol-(int)(wp->wfirst/wp->wscroll);
  1986.         return(wp->col);
  1987.     }
  1988. }
  1989.  
  1990. int inw(char c); /* IN_WORD: kein Space oder Sonderzeichen */
  1991.  
  1992. int Whndlkbd(register WINDOW *wp, int state, int key)
  1993. {  /* bei CAPS ist 0x1000 ausmaskiert!!! */
  1994.     register long i=0,fline,lline;
  1995.     int abscol,arrowed=FALSE;
  1996.     register LINESTRUCT *help;
  1997.  
  1998.     if(! wp) /* Kein Fenster */
  1999.         return(FALSE);
  2000.         
  2001.     if(! (key & 0x8000)) /* Scancodebit muß gesetzt sein */
  2002.         return(FALSE);
  2003.  
  2004.     switch(key)
  2005.     {
  2006. /**************************** NORMAL *************************************/
  2007.         case 0x8048:    /*  up    */
  2008.             graf_mouse(M_OFF,0L);
  2009.             Wcursor(wp);
  2010.             if(wp->cstr->prev)
  2011.             {
  2012.                 if(--wp->row < 0)/* scrollen */
  2013.                     Warrow(wp,WA_UPLINE);
  2014.                 else
  2015.                     wp->cstr=wp->cstr->prev; /* Cursor zurück */
  2016.                 wp->col=min(wp->cstr->used-wp->wfirst/wp->wscroll,wp->cspos);
  2017.             }
  2018.             Wshiftpage(wp,0,wp->cstr->used);
  2019.             undo.item=FALSE;
  2020.             arrowed=TRUE;
  2021.             Wcuron(wp);
  2022.             Wcursor(wp);
  2023.             break;
  2024.         case 0x8050:    /* down  */
  2025.             graf_mouse(M_OFF,0L);
  2026.             Wcursor(wp);
  2027.             if(wp->cstr->next)
  2028.             {
  2029.                 if(++wp->row > wp->hwork/wp->hscroll-1 )/* scrollen */
  2030.                     Warrow(wp,WA_DNLINE);
  2031.                 else
  2032.                     wp->cstr=wp->cstr->next; /* Cursor vor     */
  2033.                 wp->col=min(wp->cstr->used-wp->wfirst/wp->wscroll,wp->cspos);
  2034.             }
  2035.             Wshiftpage(wp,0,wp->cstr->used);
  2036.             undo.item=FALSE;
  2037.             arrowed=TRUE;
  2038.             Wcuron(wp);
  2039.             Wcursor(wp);
  2040.             break;
  2041.         case 0x804B:    /* left  */
  2042.             graf_mouse(M_OFF,0L);
  2043.             Wcursor(wp);
  2044.             wp->col--;
  2045.             if(wp->col < 1 && wp->wfirst > 0)
  2046.             {
  2047.             }
  2048.             else
  2049.             {
  2050.                 if(wp->col < 0)
  2051.                 {
  2052.                     if(wp->cstr->prev)
  2053.                     {
  2054.                         if(--wp->row < 0)/* scrollen */
  2055.                             Warrow(wp,WA_UPLINE);
  2056.                         else
  2057.                             wp->cstr=wp->cstr->prev; /* Cursor zurück */
  2058.                         wp->col = wp->cstr->used;
  2059.                     }
  2060.                 }
  2061.             }
  2062.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2063.             arrowed=TRUE;
  2064.             Wcuron(wp);
  2065.             Wcursor(wp);
  2066.             break;
  2067.         case 0x804D:    /* right */
  2068.             graf_mouse(M_OFF,0L);
  2069.             Wcursor(wp);
  2070.             if(wp->col+wp->wfirst/wp->wscroll < wp->cstr->used)
  2071.             {
  2072.                 wp->col++;
  2073.             }
  2074.             else /* bei Zeilenende Cursor eine Zeile weiter vom Anfang */
  2075.             {
  2076.                 if(wp->cstr->next)
  2077.                 {
  2078.                     if(++wp->row > wp->hwork/wp->hscroll-1 )/* scrollen */
  2079.                     {
  2080.                         Warrow(wp,WA_DNLINE);
  2081.                     }
  2082.                     else
  2083.                         wp->cstr=wp->cstr->next; /* Cursor vor     */
  2084.                     wp->col=-wp->wfirst/wp->wscroll;
  2085.                 }
  2086.             }
  2087.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2088.             arrowed=TRUE;
  2089.             Wcuron(wp);
  2090.             Wcursor(wp);
  2091.             break;
  2092.         case 0x8047:    /* Home */
  2093.             graf_mouse(M_OFF,0L);
  2094.             Wcursor(wp);
  2095.             wp->col=-wp->wfirst/wp->wscroll;
  2096.             if(wp->hsize > wp->hwork && wp->hfirst)
  2097.             {
  2098.                 wp->wfirst=wp->hfirst=0;
  2099.                 wp->row=0;
  2100.                 wp->cstr=wp->wstr=wp->fstr;    /* alles an den Anfang */
  2101.                 Wredraw(wp,&wp->xwork);
  2102.             }
  2103.             else /* doc < window, cursor auf 0 */
  2104.             {
  2105.                 wp->cstr=wp->fstr;
  2106.                 wp->row=0;
  2107.             }
  2108.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2109.             undo.item=FALSE;
  2110.             arrowed=TRUE;
  2111.             Wcuron(wp);
  2112.             Wcursor(wp);
  2113.             break;
  2114. /**************************** SHIFT **************************************/
  2115.         case 0x8248:    /*  shift up    */
  2116.             graf_mouse(M_OFF,0L);
  2117.             Wcursor(wp);
  2118.             if(wp->cstr == wp->wstr)
  2119.                 Warrow(wp,WA_UPPAGE);
  2120.             else
  2121.                 wp->cstr=wp->wstr;
  2122.             wp->col=min(wp->cstr->used-wp->wfirst/wp->wscroll,wp->cspos);
  2123.             Wshiftpage(wp,0,wp->cstr->used);
  2124.             undo.item=FALSE;
  2125.             arrowed=TRUE;
  2126.             Wcuron(wp);
  2127.             Wcursor(wp);
  2128.             break;
  2129.         case 0x8250:    /* shift down  */
  2130.             graf_mouse(M_OFF,0L);
  2131.             Wcursor(wp);
  2132.             if(wp->hsize > wp->hwork)
  2133.             {
  2134.                 for(i=0, help=wp->wstr;    /* letzte Fensterzeile suchen */
  2135.                      i<(wp->hwork/wp->hscroll-1) && help->next;
  2136.                      i++, help=help->next)
  2137.                      ;
  2138.                 if(wp->cstr == help)
  2139.                     Warrow(wp,WA_DNPAGE);
  2140.                 else
  2141.                     wp->cstr=help;
  2142.             }
  2143.             else
  2144.             {
  2145.                 while(wp->cstr->next)
  2146.                     wp->cstr=wp->cstr->next;
  2147.             }
  2148.             wp->col=min(wp->cstr->used-wp->wfirst/wp->wscroll,wp->cspos);
  2149.             Wshiftpage(wp,0,wp->cstr->used);
  2150.             undo.item=FALSE;
  2151.             arrowed=TRUE;
  2152.             Wcuron(wp);
  2153.             Wcursor(wp);
  2154.             break;
  2155.         case 0x824B:    /* shift left  */
  2156.             graf_mouse(M_OFF,0L);
  2157.             Wcursor(wp);
  2158.             wp->col=-wp->wfirst/wp->wscroll;
  2159.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2160.             arrowed=TRUE;
  2161.             Wcuron(wp);
  2162.             Wcursor(wp);
  2163.             break;
  2164.         case 0x824D:    /* shift right */
  2165.             graf_mouse(M_OFF,0L);
  2166.             Wcursor(wp);
  2167.             wp->col=wp->cstr->used-wp->wfirst/wp->wscroll;
  2168.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2169.             arrowed=TRUE;
  2170.             Wcuron(wp);
  2171.             Wcursor(wp);
  2172.             break;
  2173.         case 0x8247:    /* Clr (shift Home) */
  2174.             graf_mouse(M_OFF,0L);
  2175.             Wcursor(wp);
  2176.             wp->col=-wp->wfirst/wp->wscroll;
  2177.             fline=wp->hfirst/wp->hscroll;
  2178.             if(wp->hsize > wp->hwork && wp->hfirst != wp->hsize-wp->hwork)
  2179.             {
  2180.                 wp->hfirst = wp->hsize-wp->hwork;
  2181.                 if(wp->hfirst < 0)
  2182.                     wp->hfirst = 0;
  2183.                 lline=wp->hfirst/wp->hscroll;
  2184.                 if(lline > fline)
  2185.                 {
  2186.                     for(i=fline; i<lline; i++)
  2187.                     {
  2188.                         wp->wstr=wp->wstr->next;
  2189.                         wp->cstr=wp->cstr->next;
  2190.                     }
  2191.                     Wredraw(wp,&wp->xwork);
  2192.                 }
  2193.             }
  2194.             while(wp->cstr->next)
  2195.             {
  2196.                 wp->cstr=wp->cstr->next;
  2197.                 wp->row++;
  2198.             }
  2199.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2200.             undo.item=FALSE;
  2201.             arrowed=TRUE;
  2202.             Wcuron(wp);
  2203.             Wcursor(wp);
  2204.             break;
  2205. /**************************** CONTROL ************************************/
  2206.         case 0x8448:     /* ctrl up */
  2207.         case 0x8450:    /* ctrl dn */
  2208.             arrowed=TRUE;
  2209.            break;
  2210.         case 0x8473:     /* ctrl left  */
  2211.             graf_mouse(M_OFF,0L);
  2212.             Wcursor(wp);
  2213.             abscol=wp->col+wp->wfirst/wp->wscroll;
  2214. DACAPO_B:
  2215.             if(wp->col == 0 && wp->wfirst == 0)
  2216.             {
  2217.                 if(wp->cstr->prev)
  2218.                 {
  2219.                     if(--wp->row < 0)/* scrollen */
  2220.                     {
  2221.                         Warrow(wp,WA_UPLINE);
  2222.                     }
  2223.                     else
  2224.                         wp->cstr=wp->cstr->prev; /* Cursor zurück */
  2225.                     abscol = wp->col = wp->cstr->used;
  2226.                 }
  2227.             }
  2228.             abscol=find_prev_letter(wp->cstr->string, abscol);
  2229.             wp->col=abscol-wp->wfirst/wp->wscroll;
  2230.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2231.             if(inw(wp->cstr->string[abscol]) && wp->cstr->prev)
  2232.                 goto DACAPO_B;
  2233.             arrowed=TRUE;
  2234.             Wcuron(wp);
  2235.             Wcursor(wp);
  2236.             break;
  2237.         case 0x8474:     /* ctrl right */
  2238.             graf_mouse(M_OFF,0L);
  2239.             Wcursor(wp);
  2240.             abscol=wp->col+wp->wfirst/wp->wscroll;
  2241. DACAPO_F:
  2242.             if(!(wp->col+wp->wfirst/wp->wscroll < wp->cstr->used))
  2243.             {
  2244.                 if(wp->cstr->next)
  2245.                 {
  2246.                     if(++wp->row > wp->hwork/wp->hscroll-1 )/* scrollen */
  2247.                     {
  2248.                         Warrow(wp,WA_DNLINE);
  2249.                     }
  2250.                     else
  2251.                         wp->cstr=wp->cstr->next; /* Cursor vor     */
  2252.                     wp->col=-wp->wfirst/wp->wscroll;
  2253.                     abscol=-1;
  2254.                 }
  2255.             }
  2256.             abscol=find_next_letter(wp->cstr->string, abscol);
  2257.             wp->col=abscol-wp->wfirst/wp->wscroll;
  2258.             wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  2259.             if(inw(wp->cstr->string[abscol]) && wp->cstr->next)
  2260.                 goto DACAPO_F;
  2261.             arrowed=TRUE;
  2262.             Wcuron(wp);
  2263.             Wcursor(wp);
  2264.             break;
  2265. /************************ SHIFT-CONTROL ***********************************/
  2266.         case 0x8648:     /* shiftctrl up */
  2267.         case 0x8650:    /* shiftctrl dn */
  2268.         case 0x864B:     /* shiftctrl left  */
  2269.         case 0x8673:
  2270.         case 0x864D:     /* shiftctrl right */
  2271.         case 0x8674:
  2272.             arrowed=TRUE;
  2273.             break;
  2274.     }
  2275.     return(arrowed);
  2276. }
  2277.